package com.zenithmind.note.pojo.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.zenithmind.common.base.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

/**
 * 笔记分类实体类
 * 遵循面向对象设计原则：
 * 1. 单一职责：只负责分类数据和分类相关业务逻辑
 * 2. 封装性：提供业务方法控制分类层级和状态
 * 3. 数据完整性：确保分类层级关系的正确性
 */
@EqualsAndHashCode(callSuper = true)
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Schema(name = "笔记分类实体", description = "笔记分类实体")
@TableName("note_category")
public class NoteCategory extends BaseEntity {

    @Schema(description = "分类名称")
    @NotBlank(message = "分类名称不能为空")
    @Size(max = 50, message = "分类名称长度不能超过50个字符")
    private String name;

    @Schema(description = "分类描述")
    @Size(max = 200, message = "分类描述长度不能超过200个字符")
    private String description;

    @Schema(description = "分类图标")
    @Size(max = 100, message = "分类图标长度不能超过100个字符")
    private String icon;

    @Schema(description = "排序")
    private Integer sort;

    @Schema(description = "父级ID")
    private String parentId;

    @Schema(description = "是否系统预设")
    private Boolean isSystem;

    @Schema(description = "用户ID")
    private String userId;

    @Schema(description = "笔记数量")
    @TableField(exist = false)
    private Integer noteCount;

    // ==================== 业务方法 ====================

    /**
     * 判断是否为根分类
     *
     * @return 是否为根分类
     */
    public boolean isRootCategory() {
        return this.parentId == null || this.parentId.trim().isEmpty();
    }

    /**
     * 判断是否为子分类
     *
     * @return 是否为子分类
     */
    public boolean isSubCategory() {
        return !isRootCategory();
    }

    /**
     * 判断是否为系统预设分类
     *
     * @return 是否为系统预设
     */
    public boolean isSystemCategory() {
        return this.isSystem != null && this.isSystem;
    }

    /**
     * 判断是否为用户自定义分类
     *
     * @return 是否为用户自定义
     */
    public boolean isUserCategory() {
        return !isSystemCategory();
    }

    /**
     * 判断是否可以被删除
     *
     * @return 是否可删除
     */
    public boolean isDeletable() {
        // 系统预设分类不能删除
        if (isSystemCategory()) {
            return false;
        }

        // 有笔记的分类不能删除
        if (this.noteCount != null && this.noteCount > 0) {
            return false;
        }

        return true;
    }

    /**
     * 判断是否可以被编辑
     *
     * @param currentUserId 当前用户ID
     * @return 是否可编辑
     */
    public boolean isEditableBy(String currentUserId) {
        // 系统预设分类不能编辑
        if (isSystemCategory()) {
            return false;
        }

        // 只有创建者可以编辑
        return currentUserId != null && currentUserId.equals(this.userId);
    }

    /**
     * 设置为系统预设分类
     */
    public void setAsSystemCategory() {
        this.isSystem = true;
        this.userId = null; // 系统分类不属于任何用户
    }

    /**
     * 设置为用户自定义分类
     *
     * @param userId 用户ID
     */
    public void setAsUserCategory(String userId) {
        if (userId == null || userId.trim().isEmpty()) {
            throw new IllegalArgumentException("用户ID不能为空");
        }
        this.isSystem = false;
        this.userId = userId;
    }

    /**
     * 初始化新分类的默认值
     */
    public void initializeDefaults() {
        if (this.sort == null) {
            this.sort = 0;
        }
        if (this.isSystem == null) {
            this.isSystem = false;
        }
        if (this.noteCount == null) {
            this.noteCount = 0;
        }
    }

    /**
     * 验证分类数据是否有效
     *
     * @return 是否有效
     */
    public boolean isValid() {
        return this.name != null && !this.name.trim().isEmpty() &&
               this.name.length() <= 50;
    }
}